package com.imarkket.sqlite.handler;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.text.BoringLayout;

import com.imarkket.Library.c_logging;
import com.imarkket.sqlite.model.t_lista_producto;
import com.imarkket.sqlite.model.t_producto;
import com.imarkket.sqlite.model.t_lista;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

/**
 * Created by Sistemas on 04/06/2014.
 */

public class c_bd_handler extends SQLiteOpenHelper {

    // Logcat tag
    private static final String LOG = c_bd_handler.class.getName();

    // Database Version
    private static final int DATABASE_VERSION = 1;

    // Database Name
    private static final String DATABASE_NAME = "imarkket.db";

    // Table Names
    private static final String TABLE_LISTA = "T_LISTA";
    private static final String TABLE_PRODUCTO = "T_PRODUCTO";
    private static final String TABLE_LISTA_PRODUCTO = "T_LISTA_PRODUCTO";

    // Column names
    private static final String KEY_NCOD_INTERNO = "NCOD_INTERNO";

    private static final String KEY_ADES_LARGA = "ADES_LARGA";
    private static final String KEY_ADES_HASH = "ADES_HASH";

    private static final String KEY_NCOD_COUNT = "NCOD_COUNT";
    private static final String KEY_NCOD_SHARED = "NCOD_SHARED";
    private static final String KEY_NCOD_RATING = "NCOD_RATING";

    private static final String KEY_DFEC_CREACION = "DFEC_CREACION";
    private static final String KEY_DFEC_UPDATED = "DFEC_UPDATED";

    private static final String KEY_LISTA_HASH = "HASH_LISTA";
    private static final String KEY_PRODUCTO_HASH = "HASH_PRODUCTO";

    private static final String KEY_NCOD_TOTAL_PRODUCTOS = "NCOD_TOTAL_PRODUCTOS";

    // Table Create Statements
    private static final String CREATE_TABLE_LISTA =
            "CREATE TABLE IF NOT EXISTS " + TABLE_LISTA + "(" +
                    KEY_NCOD_INTERNO + " INTEGER PRIMARY KEY AUTOINCREMENT," +

                    KEY_ADES_LARGA + " TEXT," +
                    KEY_ADES_HASH + " TEXT," +

                    KEY_NCOD_COUNT + " INTEGER," +
                    KEY_NCOD_SHARED + " INTEGER," +
                    KEY_NCOD_RATING + " INTEGER," +

                    KEY_DFEC_CREACION + " DATETIME, " +
                    KEY_DFEC_UPDATED + " DATETIME" + ")";

    // Tag table create statement
    private static final String CREATE_TABLE_PRODUCTO =
            "CREATE TABLE IF NOT EXISTS " + TABLE_PRODUCTO + "(" +
                    KEY_NCOD_INTERNO + " INTEGER PRIMARY KEY AUTOINCREMENT," +

                    KEY_ADES_LARGA + " TEXT," +
                    KEY_ADES_HASH + " TEXT," +

                    KEY_DFEC_CREACION + " DATETIME, " +
                    KEY_DFEC_UPDATED + " DATETIME" + ")";

    // ELEMENTO_LISTA table create statement
    private static final String CREATE_TABLE_LISTA_PRODUCTO =
            "CREATE TABLE IF NOT EXISTS " + TABLE_LISTA_PRODUCTO + "(" +
                    KEY_NCOD_INTERNO + " INTEGER PRIMARY KEY AUTOINCREMENT," +

                    KEY_LISTA_HASH + " TEXT," +
                    KEY_PRODUCTO_HASH + " TEXT," +

                    KEY_NCOD_TOTAL_PRODUCTOS + " INTEGER, " +

                    KEY_DFEC_CREACION + " DATETIME, " +
                    KEY_DFEC_UPDATED + " DATETIME" + ")";

    public c_bd_handler(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // creating required tables
        c_logging.getInstance().log(c_logging.LOG_INFO, "Constructor::" + LOG + "\n");

        c_logging.getInstance().log(c_logging.LOG_INFO, "Borrando DB..." );
        //db.execSQL("DROP TABLE IF EXISTS " + TABLE_LISTA);
        //db.execSQL("DROP TABLE IF EXISTS " + TABLE_PRODUCTO);
        //db.execSQL("DROP TABLE IF EXISTS " + TABLE_LISTA_PRODUCTO);

        c_logging.getInstance().log(c_logging.LOG_INFO, "Creando if not exists DB..." );
        db.execSQL(CREATE_TABLE_LISTA);
        db.execSQL(CREATE_TABLE_PRODUCTO);
        db.execSQL(CREATE_TABLE_LISTA_PRODUCTO);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // on upgrade drop older tables
        // Después de getWritable o getReadable se ejecute
        // onCreate onUpdate onOpen

        c_logging.getInstance().log(c_logging.LOG_INFO, "Updating DB..." );
        //db.execSQL("DROP TABLE IF EXISTS " + TABLE_LISTA);
        //db.execSQL("DROP TABLE IF EXISTS " + TABLE_PRODUCTO);
        //db.execSQL("DROP TABLE IF EXISTS " + TABLE_LISTA_PRODUCTO);

        c_logging.getInstance().log(c_logging.LOG_INFO, "Creando if not exists DB..." );
        db.execSQL(CREATE_TABLE_LISTA);
        db.execSQL(CREATE_TABLE_PRODUCTO);
        db.execSQL(CREATE_TABLE_LISTA_PRODUCTO);

        // create new tables
        //onCreate(db);
    }

    public void fnc_bd_handler_init (Context context) {
        // Este procedimiento solo se se debe utilizar para:
        //  - depurar
        //  - cargar datos en la BD
        //  - Borrar
        //    ...

        // Llamamos a la Base de Datos
        SQLiteDatabase db = this.getWritableDatabase();

        File dbFile = context.getDatabasePath(DATABASE_NAME);
        c_logging.getInstance().log(c_logging.LOG_INFO, "Init DB: " + dbFile.toString() );

        c_logging.getInstance().log(c_logging.LOG_INFO, "Creando if not exists DB..." );
        db.execSQL(CREATE_TABLE_LISTA);
        db.execSQL(CREATE_TABLE_PRODUCTO);
        db.execSQL(CREATE_TABLE_LISTA_PRODUCTO);
    }

    public void fnc_delete_all_tables (Context context) {
        // Este procedimiento solo se se debe utilizar para:
        //  - depurar
        //  - cargar datos en la BD
        //  - Borrar
        //    ...

        // Llamamos a la Base de Datos
        SQLiteDatabase db = this.getWritableDatabase();

        File dbFile = context.getDatabasePath(DATABASE_NAME);
        c_logging.getInstance().log(c_logging.LOG_INFO, "REINICIANDO BASE DE DATOS: " + dbFile.toString() );

        c_logging.getInstance().log(c_logging.LOG_INFO, "Borrando DB..." );
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_LISTA);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_PRODUCTO);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_LISTA_PRODUCTO);

        c_logging.getInstance().log(c_logging.LOG_INFO, "Creando if not exists DB..." );
        db.execSQL(CREATE_TABLE_LISTA);
        db.execSQL(CREATE_TABLE_PRODUCTO);
        db.execSQL(CREATE_TABLE_LISTA_PRODUCTO);
    }

    public void fnc_close_database () {
        SQLiteDatabase db = this.getReadableDatabase();
        db.close();
        return;
    }

    // Busca dentro de la tabla lista_producto que no exista ya ese elemento
    // TODO si ya existe ese elemento update en el t_producto count
    public Boolean fnc_find_tabla_lista_producto ( String pTABLE, String pLista_HASH, String pProducto_HASH ) {
        String selectQuery = "SELECT * FROM " + pTABLE + " WHERE " + KEY_LISTA_HASH + "='" + pLista_HASH +"'";
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        Boolean encontrado = false;

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "find t_l_p A ("+ pLista_HASH +"): *" + c.getString(c.getColumnIndex(KEY_PRODUCTO_HASH)) + "* <-> *" + pProducto_HASH + "*" );
                if (c.getString(c.getColumnIndex(KEY_PRODUCTO_HASH)).equals( pProducto_HASH )) {
                    // c.position es el índice con la posición de este elemento en el cursor
                    c_logging.getInstance().log(c_logging.LOG_INFO, "element id: " + c.getPosition());
                    encontrado = true;
                }
            } while (c.moveToNext() && (!encontrado));
        }

        // false no lo encuentra
        // otro valor indica la posición en el cursor
        if (encontrado) {
            c_logging.getInstance().log(c_logging.LOG_INFO, "ENCONTRADO");
            return true;
        }
        else {
            c_logging.getInstance().log(c_logging.LOG_INFO, "NO ENCONTRADO");
            return false;
        }

    }
    // Para buscar si hay duplicados en una tabla
    public Boolean fnc_find_tabla_hash ( String pTABLE, String pHASH ) {
        String selectQuery = "SELECT * FROM " + pTABLE;
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        Boolean encontrado = false;

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "find hash A: *" + c.getString(c.getColumnIndex(KEY_ADES_HASH)) + "* <-> *" + pHASH + "*" );
                if (c.getString(c.getColumnIndex(KEY_ADES_HASH)).equals( pHASH )) {
                    // c.position es el índice con la posición de este elemento en el cursor
                    c_logging.getInstance().log(c_logging.LOG_INFO, "element id: " + c.getPosition());
                    encontrado = true;
                }
            } while (c.moveToNext() && (!encontrado));
        }

        // false no lo encuentra
        // otro valor indica la posición en el cursor
        if (encontrado) {
            c_logging.getInstance().log(c_logging.LOG_INFO, "ENCONTRADO");
            return true;
        }
        else {
            c_logging.getInstance().log(c_logging.LOG_INFO, "NO ENCONTRADO");
            return false;
        }
    }

    // Para buscar si hay duplicados en una tabla
    public Boolean fnc_find_producto_T_PRODUCTO ( String pHASH ) {
        String selectQuery = "SELECT * FROM " + TABLE_PRODUCTO;
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        Boolean encontrado = false;

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "find t_p A: *" + c.getString(c.getColumnIndex(KEY_ADES_HASH)) + "* <-> *" + pHASH + "*" );
                if (c.getString(c.getColumnIndex(KEY_ADES_HASH)).equals( pHASH )) {
                    // c.position es el índice con la posición de este elemento en el cursor
                    c_logging.getInstance().log(c_logging.LOG_INFO, "element id: " + c.getPosition());
                    encontrado = true;
                }
            } while (c.moveToNext() && (!encontrado));
        }

        // false no lo encuentra
        // otro valor indica la posición en el cursor
        if (encontrado)
            return true;
        else
            return false;
    }

    // Busca dentro de la tabla lista_producto que no exista ya ese elemento
    // TODO si ya existe ese elemento update en el t_producto count
    public Boolean fnc_find_producto_T_LISTA_PRODUCTO ( String pLista_HASH, String pProducto_HASH ) {
        String selectQuery = "SELECT * FROM " + TABLE_LISTA_PRODUCTO + " WHERE " + KEY_LISTA_HASH + "='" + pLista_HASH +"'";
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        Boolean encontrado = false;

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "find t_l_p A ("+ pLista_HASH +"): *" + c.getString(c.getColumnIndex(KEY_PRODUCTO_HASH)) + "* <-> *" + pProducto_HASH + "*" );
                if (c.getString(c.getColumnIndex(KEY_PRODUCTO_HASH)).equals( pProducto_HASH )) {
                    // c.position es el índice con la posición de este elemento en el cursor
                    c_logging.getInstance().log(c_logging.LOG_INFO, "element id: " + c.getPosition());
                    encontrado = true;
                }
            } while (c.moveToNext() && (!encontrado));
        }

        // false no lo encuentra
        // otro valor indica la posición en el cursor
        if (encontrado)
            return true;
        else
            return false;

    }


    public List<t_lista> fnc_get_All_T_LISTA() {
        List<t_lista> tags = new ArrayList<t_lista>();
        String selectQuery = "SELECT * FROM " + TABLE_LISTA;

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                t_lista t = new t_lista();
                t.setNCOD_INTERNO(c.getInt(c.getColumnIndex(KEY_NCOD_INTERNO)));
                t.setADES_HASH(c.getString(c.getColumnIndex(KEY_ADES_HASH)));
                t.setADES_LARGA(c.getString(c.getColumnIndex(KEY_ADES_LARGA)));
                t.setNCOD_SHARED(c.getInt(c.getColumnIndex(KEY_NCOD_SHARED)));
                t.setNCOD_COUNT(c.getInt(c.getColumnIndex(KEY_NCOD_COUNT)));
                t.setNCOD_RATING(c.getInt(c.getColumnIndex(KEY_NCOD_RATING)));
                t.setDFEC_CREACION(c.getString(c.getColumnIndex(KEY_DFEC_CREACION)));
                t.setDFEC_UPDATE(c.getString(c.getColumnIndex(KEY_DFEC_UPDATED)));

                c_logging.getInstance().log(c_logging.LOG_INFO, TABLE_LISTA + " - i:" + t.getNCOD_INTERNO() + " - "

                        + t.getADES_LARGA () + " - "
                        + t.getADES_HASH  ()+ " - "

                        + t.getNCOD_SHARED  ()+ " - "
                        + t.getNCOD_COUNT () + " - "
                        + t.getNCOD_RATING ()  + " - "

                        + t.getDFEC_CREACION ().toString() + " - "
                        + t.getDFEC_UPDATE ().toString() );

                // adding to tags list
                tags.add(t);
            } while (c.moveToNext());
        }
        return tags;
    }

    public List<t_lista_producto> fnc_get_All_T_LISTA_PRODUCTO( String pNCOD_HASH_LISTA ) {
        List<t_lista_producto> tags = new ArrayList<t_lista_producto>();

        String selectQuery = "";

        // Si no se define el el hash de la lista, contamos todos los elementos
        if (pNCOD_HASH_LISTA.isEmpty()) {
            selectQuery = "SELECT * FROM " + TABLE_LISTA_PRODUCTO;
        } else {
            selectQuery = "SELECT * FROM " + TABLE_LISTA_PRODUCTO + " WHERE " + KEY_LISTA_HASH + " = '" + pNCOD_HASH_LISTA + "'";
        }

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                t_lista_producto t = new t_lista_producto();
                t.setNCOD_INTERNO(c.getInt(c.getColumnIndex(KEY_NCOD_INTERNO)));
                t.setNCOD_LISTA(c.getString(c.getColumnIndex(KEY_LISTA_HASH)));
                t.setNCOD_PRODUCTO(c.getString(c.getColumnIndex(KEY_PRODUCTO_HASH)));
                t.setNCOD_TOTAL_PRODUCTOS(c.getInt(c.getColumnIndex(KEY_NCOD_TOTAL_PRODUCTOS)));
                t.setDFEC_CREACION(c.getString(c.getColumnIndex(KEY_DFEC_CREACION)));
                t.setDFEC_UPDATE(c.getString(c.getColumnIndex(KEY_DFEC_UPDATED)));

                c_logging.getInstance().log(c_logging.LOG_INFO, TABLE_LISTA_PRODUCTO + " - i:" + t.getNCOD_INTERNO() + " - "

                        + t.getLISTA_HASH () + " - "
                        + t.getPRODUCTO_HASH() + " - "

                        + t.getNCOD_TOTAL_PRODUCTOS() + " - "

                        + t.getDFEC_CREACION ().toString() + " - "
                        + t.getDFEC_UPDATE ().toString() );

                // adding to tags list
                tags.add(t);
            } while (c.moveToNext());
        }
        return tags;
    }

    // Para buscar si hay duplicados en una tabla
    public String fnc_getT_LISTA_ADES_LARGA ( String pHASH ) {
        String selectQuery = "SELECT * FROM " + TABLE_LISTA + " WHERE " + KEY_ADES_HASH + " = '" + pHASH + "'";
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        Boolean encontrado = false;

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "get lista A: *" + c.getString(c.getColumnIndex(KEY_ADES_HASH)) + "* <-> *" + pHASH + "*" );
                if (c.getString(c.getColumnIndex(KEY_ADES_HASH)).equals( pHASH )) {
                    encontrado = true;
                    c_logging.getInstance().log(c_logging.LOG_INFO, "Encontrado --> " + pHASH + " --> " + c.getString(c.getColumnIndex(KEY_ADES_LARGA)) );
                    return c.getString(c.getColumnIndex(KEY_ADES_LARGA));
                }
            } while (c.moveToNext());
        }

        return "NOT_FOUND_LIST_BY_HASH";
    }

    public List<t_producto> fnc_get_All_T_PRODUCTO( ) {
        List<t_producto> tags = new ArrayList<t_producto>();
        String selectQuery = "SELECT * FROM " + TABLE_PRODUCTO;

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                t_producto t = new t_producto();
                t.setNCOD_INTERNO(c.getInt(c.getColumnIndex(KEY_NCOD_INTERNO)));

                t.setADES_HASH(c.getString(c.getColumnIndex(KEY_ADES_HASH)));
                t.setADES_LARGA(c.getString(c.getColumnIndex(KEY_ADES_LARGA)));

                t.setDFEC_CREACION(c.getString(c.getColumnIndex(KEY_DFEC_CREACION)));
                t.setDFEC_UPDATE(c.getString(c.getColumnIndex(KEY_DFEC_UPDATED)));

                c_logging.getInstance().log(c_logging.LOG_INFO, TABLE_PRODUCTO + " - i:" + t.getNCOD_INTERNO() + " - "

                        + t.getADES_LARGA () + " - "
                        + t.getADES_HASH  ()+ " - "

                        + t.getDFEC_CREACION ().toString() + " - "
                        + t.getDFEC_UPDATE ().toString() );

                // adding to tags list
                tags.add(t);
            } while (c.moveToNext());
        }
        return tags;
    }

    public String[][] fnc_export_lista ( int pTotal ) {
        String selectQuery = "SELECT * FROM " + TABLE_LISTA + " ORDER BY " + KEY_DFEC_UPDATED + " DESC ";
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);
        c_logging.getInstance().log(c_logging.LOG_INFO, "Elmentos Actual: " + pTotal);
        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // Matriz Bidimensional
        // Matriz de n Elementos y 8 columnas, el total de características de cada lista de la compra
        String[][] MatrizBidimensional = new String[pTotal][8];

        int i = 0;
        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "iterate: " + i );
                // Extremos los datos del JSON
                MatrizBidimensional[i][0] = c.getString(c.getColumnIndex(KEY_NCOD_INTERNO));

                MatrizBidimensional[i][1] = c.getString(c.getColumnIndex(KEY_ADES_HASH));
                MatrizBidimensional[i][2] = c.getString(c.getColumnIndex(KEY_ADES_LARGA));

                MatrizBidimensional[i][3] = c.getString(c.getColumnIndex(KEY_NCOD_SHARED));
                MatrizBidimensional[i][4] = c.getString(c.getColumnIndex(KEY_NCOD_COUNT));
                MatrizBidimensional[i][5] = c.getString(c.getColumnIndex(KEY_NCOD_RATING));

                MatrizBidimensional[i][6] = c.getString(c.getColumnIndex(KEY_DFEC_CREACION));
                MatrizBidimensional[i][7] = c.getString(c.getColumnIndex(KEY_DFEC_UPDATED));

                c_logging.getInstance().log(c_logging.LOG_INFO, "0 KEY_NCOD_INTERNO: " + MatrizBidimensional[i][0]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "1 KEY_ADES_HASH: " + MatrizBidimensional[i][1]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "2 KEY_ADES_LARGA: " + MatrizBidimensional[i][2]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "3 KEY_NCOD_SHARED: " + MatrizBidimensional[i][3]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "4 KEY_NCOD_COUNT: " + MatrizBidimensional[i][4]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "5 KEY_NCOD_RATING: " + MatrizBidimensional[i][5]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "6 KEY_DFEC_CREACION: " + MatrizBidimensional[i][6]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "7 KEY_DFEC_UPDATED: " + MatrizBidimensional[i][7]);

                i++;
            } while (c.moveToNext());
        }

        return MatrizBidimensional;
    }

    public String[][] fnc_export_lista_producto ( int pTotal, String pListaHASH ) {

        String selectQuery = "SELECT " +
                             "       LP." + KEY_NCOD_TOTAL_PRODUCTOS + ", " +

                             "       P." + KEY_NCOD_INTERNO + ", " +

                             "       P." + KEY_ADES_HASH + ", " +
                             "       P." + KEY_ADES_LARGA + ", " +

                             "       P." + KEY_DFEC_UPDATED + ", " +
                             "       P." + KEY_DFEC_CREACION + " " +

                             "      FROM " + TABLE_LISTA_PRODUCTO + " LP, " +
                             "           " + TABLE_PRODUCTO + " P " +
                             "      WHERE LP." + KEY_LISTA_HASH + "='" + pListaHASH + "' AND " +
                             "            LP." + KEY_PRODUCTO_HASH + "=" +  "P."+KEY_ADES_HASH +
                             "      ORDER BY P." + KEY_DFEC_UPDATED + " DESC ";

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);
        c_logging.getInstance().log(c_logging.LOG_INFO, ">lista_producto JOIN producto: " + pListaHASH + " Actual: " + pTotal);
        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // Matriz Bidimensional
        // Matriz de n Elementos y 8 columnas, el total de características de cada lista de la compra
        String[][] MatrizBidimensional = new String[pTotal][6];

        int i = 0;
        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "iterate: " + i );
                // Extremos los datos del JSON
                MatrizBidimensional[i][0] = c.getString(c.getColumnIndex(KEY_NCOD_TOTAL_PRODUCTOS));

                MatrizBidimensional[i][1] = c.getString(c.getColumnIndex(KEY_NCOD_INTERNO));

                MatrizBidimensional[i][2] = c.getString(c.getColumnIndex(KEY_ADES_LARGA));
                MatrizBidimensional[i][3] = c.getString(c.getColumnIndex(KEY_ADES_HASH));

                MatrizBidimensional[i][4] = c.getString(c.getColumnIndex(KEY_DFEC_UPDATED));
                MatrizBidimensional[i][5] = c.getString(c.getColumnIndex(KEY_DFEC_CREACION));

                c_logging.getInstance().log(c_logging.LOG_INFO, "1 KEY_NCOD_TOTAL_PRODUCTOS: " + MatrizBidimensional[i][0]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "2 KEY_NCOD_INTERNO: " + MatrizBidimensional[i][1]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "3 KEY_ADES_LARGA: " + MatrizBidimensional[i][2]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "4 KEY_ADES_HASH: " + MatrizBidimensional[i][3]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "5 KEY_DFEC_CREACION: " + MatrizBidimensional[i][4]);
                c_logging.getInstance().log(c_logging.LOG_INFO, "6 KEY_DFEC_UPDATED: " + MatrizBidimensional[i][5]);

                i++;
            } while (c.moveToNext());
        }

        return MatrizBidimensional;
    }

    // TABLA T_LISTA
    public long fnc_insert_table_lista ( t_lista pLista ) {

        // Llamamos a la Base de Datos
        SQLiteDatabase db = this.getWritableDatabase();

        // Contenedor de Valores
        ContentValues values = new ContentValues();

        // Obtenemos los valores de la clase t_lista que se crean en el constructor al llamar al
        // new de t_lista

        // Desactivo este campo, ya que al ser AUTO INCREMENT  no hace falta.
        //values.put(KEY_NCOD_INTERNO, pLista.getNCOD_INTERNO());
        values.put(KEY_ADES_HASH, pLista.getADES_HASH());
        values.put(KEY_ADES_LARGA, pLista.getADES_LARGA());

        values.put(KEY_NCOD_SHARED, pLista.getNCOD_SHARED());
        values.put(KEY_NCOD_COUNT, pLista.getNCOD_COUNT());
        values.put(KEY_NCOD_RATING, pLista.getNCOD_RATING());

        values.put(KEY_DFEC_CREACION, pLista.getDFEC_CREACION().toString());
        values.put(KEY_DFEC_UPDATED, pLista.getDFEC_UPDATE().toString());

        // Buscamos si hay duplicado antes de insertar
        if (fnc_find_tabla_hash( TABLE_LISTA, pLista.getADES_HASH())) {
            c_logging.getInstance().log(c_logging.LOG_INFO, "HASH LISTA: " + pLista.getADES_HASH() + " DUPLICATED!!!" );
            // Si está repetido devulvo -2  para no duplicarlo
            return -2;
        } else {
            // insert row
            c_logging.getInstance().log(c_logging.LOG_INFO, "HASH LISTA: " + pLista.getADES_HASH() + " INSERTING!!!" );
            return (db.insert(TABLE_LISTA, null, values));
        }
    }

    // TABLA T_PRODUCTO
    public long fnc_insert_table_producto ( t_producto pProducto ) {

        c_logging.getInstance().log(c_logging.LOG_INFO, "Insertando producto..." );

        // Llamamos a la Base de Datos
        SQLiteDatabase db = this.getWritableDatabase();

        // Contenedor de Valores
        ContentValues values = new ContentValues();

        // Obtenemos los valores de la clase t_producto que se crean en el constructor al llamar al
        // new de t_producto

        // Desactivo este campo, ya que al ser AUTO INCREMENT  no hace falta.
        //values.put(KEY_NCOD_INTERNO, pProducto.getNCOD_INTERNO());
        values.put(KEY_ADES_HASH, pProducto.getADES_HASH());
        values.put(KEY_ADES_LARGA, pProducto.getADES_LARGA());

        values.put(KEY_DFEC_CREACION, pProducto.getDFEC_CREACION().toString());
        values.put(KEY_DFEC_UPDATED, pProducto.getDFEC_UPDATE().toString());

        // Buscamos si hay duplicado antes de insertar
        if (fnc_find_tabla_hash( TABLE_PRODUCTO, pProducto.getADES_HASH())) {
            c_logging.getInstance().log(c_logging.LOG_INFO, "HASH PRODUCTO: id -> " + pProducto.getADES_HASH() + " DUPLICATED!!!" );
            // Si está repetido devulvo -2 para no duplicarlo
            return -2;
        } else {
            // insert row
            c_logging.getInstance().log(c_logging.LOG_INFO, "HASH PRODUCTO: id " + pProducto.getADES_HASH() + " INSERTING!!!" );
            return (db.insert(TABLE_PRODUCTO, null, values));
        }
    }

    // TABLA T_PRODUCTO
    public long fnc_insert_table_lista_producto ( t_lista_producto pLista_Producto, String pListaHASH, String pProductoHASH ) {

        // Llamamos a la Base de Datos
        SQLiteDatabase db = this.getWritableDatabase();

        // Contenedor de Valores
        ContentValues values = new ContentValues();

        // Obtenemos los valores de la clase t_producto que se crean en el constructor al llamar al
        // new de t_producto

        // Desactivo este campo, ya que al ser AUTO INCREMENT  no hace falta.
        // values.put(KEY_NCOD_INTERNO, pLista_Producto.getNCOD_INTERNO());

        values.put(KEY_LISTA_HASH, pLista_Producto.getLISTA_HASH());
        values.put(KEY_PRODUCTO_HASH, pLista_Producto.getPRODUCTO_HASH());

        values.put(KEY_NCOD_TOTAL_PRODUCTOS, pLista_Producto.getNCOD_TOTAL_PRODUCTOS());

        values.put(KEY_DFEC_CREACION, pLista_Producto.getDFEC_CREACION().toString());
        values.put(KEY_DFEC_UPDATED, pLista_Producto.getDFEC_UPDATE().toString());

        // Buscamos si hay duplicado antes de insertar
        if (fnc_find_tabla_lista_producto ( TABLE_LISTA_PRODUCTO, pListaHASH, pProductoHASH)) {
            c_logging.getInstance().log(c_logging.LOG_INFO, "HASH LISTA PRODUCTO: " + pProductoHASH + " DUPLICATED!!!");
            // si está repetido devuelvo -2 para no duplicarlo
            return -2;
        } else {
            // insert row
            c_logging.getInstance().log(c_logging.LOG_INFO, "HASH LISTA PRODUCTO: " + pProductoHASH + " INSERTING!!!" );
            return (db.insert(TABLE_LISTA_PRODUCTO, null, values));
        }

    }

    // Actualizar el campo fecha de la lista
    public int fnc_update_table_lista ( String pListaHASH, int pIncrementoLista ) {

        //Getting Current Time
        Calendar ctaq = Calendar.getInstance();
        SimpleDateFormat dfaq = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        SQLiteDatabase db = this.getReadableDatabase();

        ContentValues newValues = new ContentValues();
        newValues.put(KEY_DFEC_UPDATED, dfaq.format(ctaq.getTime()));
        newValues.put(KEY_NCOD_COUNT, pIncrementoLista);

        c_logging.getInstance().log(c_logging.LOG_INFO, "UPDATE: " + pListaHASH + " --> " + pIncrementoLista );
        return (db.update(TABLE_LISTA, newValues, KEY_ADES_HASH + "='" + pListaHASH + "'", null));
    }

    // Actualizar el campo fecha del producto
    public int fnc_update_table_producto ( String pPRODUCTO ) {

        c_logging.getInstance().log(c_logging.LOG_INFO, "UPDATE T_PRODUCTO" );

        //Getting Current Time
        Calendar ctaq = Calendar.getInstance();
        SimpleDateFormat dfaq = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        SQLiteDatabase db = this.getReadableDatabase();

        ContentValues newValues = new ContentValues();
        newValues.put(KEY_DFEC_UPDATED, dfaq.format(ctaq.getTime()));

        return (db.update(TABLE_PRODUCTO, newValues, KEY_ADES_HASH + "='" + pPRODUCTO + "'", null));
    }

    // Actualizar el campo fecha del producto
    public int fnc_update_table_lista_producto ( String pLISTA, String pPRODUCTO, int pIncrementoLista ) {

        c_logging.getInstance().log(c_logging.LOG_INFO, "UPDATE T_LISTA_PRODUCTO" );

        //Getting Current Time
        Calendar ctaq = Calendar.getInstance();
        SimpleDateFormat dfaq = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        SQLiteDatabase db = this.getReadableDatabase();

        ContentValues newValues = new ContentValues();
        newValues.put(KEY_DFEC_UPDATED, dfaq.format(ctaq.getTime()));
        newValues.put(KEY_NCOD_TOTAL_PRODUCTOS, pIncrementoLista );

        return (db.update(TABLE_LISTA_PRODUCTO, newValues, KEY_LISTA_HASH + "='" + pLISTA + "' and "+KEY_PRODUCTO_HASH+ "='" + pPRODUCTO + "'", null));
    }

    // Contar el número de veces que un producto está en una lista
    public int fnc_count_producto_en_lista_producto ( String pListaHASH, String pProductoHASH ) {

        c_logging.getInstance().log(c_logging.LOG_INFO, "GET COUNT LISTA_PRODUCTO ( "+ pListaHASH +" , " + pProductoHASH + " )" );

        String selectQuery = "SELECT "+KEY_NCOD_TOTAL_PRODUCTOS +
                "      FROM " + TABLE_LISTA_PRODUCTO +
                "      WHERE " + KEY_LISTA_HASH    + "='" + pListaHASH    + "' AND " +
                "            " + KEY_PRODUCTO_HASH + "='" + pProductoHASH + "' ";

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);
        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        c.moveToFirst();
        int count= c.getInt(c.getColumnIndex(KEY_NCOD_TOTAL_PRODUCTOS));
        c.close();

        return count;
    }

    public List<String> fnc_getAll_Productos(){
        List<String> labels = new ArrayList<String>();

        // Select All Query
        String selectQuery = "SELECT * FROM " + TABLE_PRODUCTO;

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                labels.add(c.getString(1));
            } while (c.moveToNext());
        }

        // returning lables
        return labels;
    }

    public void fnc_Borrar_Producto_Lista ( String pListaHASH, String pProductoHASH ) {

        // Por ahora borramos todos los productos, aunque haya 200, posteriormente se borrarán indicando el número.
        String selectQuery = "DELETE FROM " + TABLE_LISTA_PRODUCTO + " WHERE " + KEY_LISTA_HASH + "='" + pListaHASH +"' and " + KEY_PRODUCTO_HASH + "='" + pProductoHASH +"'";
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        db.execSQL(selectQuery);

        c_logging.getInstance().log(c_logging.LOG_INFO, "Borrando: LISTA: " + pListaHASH + " PRODUCTO: " + pProductoHASH);

    }

    public int fnc_get_lista_count ( String pListaHASH ) {

        String selectQuery = "SELECT "+ KEY_NCOD_COUNT +
                "      FROM " + TABLE_LISTA +
                "      WHERE " + KEY_ADES_HASH    + "='" + pListaHASH    + "' ";

        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + selectQuery);
        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        c.moveToFirst();
        int count= c.getInt(c.getColumnIndex(KEY_NCOD_COUNT));
        c.close();

        return count;
    }

    public void fnc_Delete_Producto_Huerfano ( String pProductoHASH ) {

        // Mostramos los elementos a borrar
        String QueryLP = "SELECT distinct(" + KEY_PRODUCTO_HASH + ") FROM " + TABLE_LISTA_PRODUCTO;
        String QueryNOTin = "SELECT " + KEY_ADES_HASH + " FROM " + TABLE_PRODUCTO + " WHERE " + KEY_ADES_HASH + " NOT in ( " + QueryLP  + " )";
        c_logging.getInstance().log(c_logging.LOG_INFO, "SQL: " + QueryNOTin);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(QueryNOTin, null);

        int i = 0;
        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                c_logging.getInstance().log(c_logging.LOG_INFO, "[" + i + "] KEY_PRODUCTO_HASH Huérfano: " +c.getString(c.getColumnIndex(KEY_ADES_HASH)));

                i++;
            } while (c.moveToNext());
        }

        // Borramos los elementos
        String QueryDELETE = "DELETE FROM " + TABLE_PRODUCTO + " WHERE " + KEY_ADES_HASH + " in ( " + QueryNOTin + " )";
        db.rawQuery(QueryDELETE, null);
    }

/*
    // TABLA T_ELEMENTO
    public long createT_ELEMENTO( t_producto pITEM ) {



        // Llamamos a la Base de Datos
        SQLiteDatabase db = this.getWritableDatabase();

        // Contenedor de Valores
        ContentValues values = new ContentValues();

        // Obtenemos los valores de la clase T_ELEMENTO que se crean en el constructor al llamar al
        // new de t_elemento
        values.put(KEY_NCOD_INTERNO, pITEM.getNCOD_INTERNO());
        values.put(KEY_ADES_HASH, pITEM.getADES_HASH());
        values.put(KEY_ADES_LARGA, pITEM.getADES_LARGA());
        values.put(KEY_DFEC_CREACION, pITEM.getDFEC_CREACION() );

        // insert row
        long tag_id = db.insert(TABLE_ELEMENTO, null, values);

        return tag_id;
    }

    public List<t_producto> getAllELEMENTOS() {
        List<t_producto> tags = new ArrayList<t_producto>();
        String selectQuery = "SELECT  * FROM " + TABLE_ELEMENTO;

        c_logging.getInstance().log(c_logging.LOG_INFO, selectQuery);

        SQLiteDatabase db = this.getReadableDatabase();
        Cursor c = db.rawQuery(selectQuery, null);

        // looping through all rows and adding to list
        if (c.moveToFirst()) {
            do {
                t_producto t = new t_producto();
                t.setNCOD_INTERNO(c.getInt((c.getColumnIndex(KEY_NCOD_INTERNO))));
                t.setADES_LARGA(c.getString(c.getColumnIndex(KEY_ADES_LARGA)));
                t.setADES_HASH(c.getString(c.getColumnIndex(KEY_ADES_HASH)));
                t.setDFEC_CREACION(c.getString(c.getColumnIndex(KEY_DFEC_CREACION)));

                c_logging.getInstance().log(c_logging.LOG_INFO, t.getNCOD_INTERNO() + " - " + t.getADES_HASH() + " - " + t.getADES_LARGA() + " - " + t.getDFEC_CREACION() );

                // adding to tags list
                tags.add(t);
            } while (c.moveToNext());
        }
        return tags;
    }



/*
    private void copiarBaseDatos( Context context ) {
        String ruta = "/data/data/com.imarkket.sqlite/handler/databases/";
        String archivoIS = "contactos.db";
        String archivoOS = "contactos.db";
        File archivoDBIS = new File(ruta + archivoIS);
        File archivoDBOS = new File(ruta + archivoOS);
        if (!archivoDBIS.exists()) {
            try {
                InputStream IS = context.getAssets().open(archivoIS);
                OutputStream OS = new FileOutputStream(archivoDBOS);
                byte[] buffer = new byte[1024];
                int length = 0;
                while ((length = IS.read(buffer)) > 0) {
                    OS.write(buffer, 0, length);
                }
                OS.flush();
                OS.close();
                IS.close();
            } catch (FileNotFoundException e) {
                Log.e("ERROR", "Archivo no encontrado, " + e.toString());
            } catch (IOException e) {
                Log.e("ERROR", "Error al copiar la Base de Datos, " + e.toString());
            }
        }
    }
*/
        /*

        // Creating a todo

        public long createToDo(t_lista todo, long[] tag_ids) {
            SQLiteDatabase db = this.getWritableDatabase();

            ContentValues values = new ContentValues();
            values.put(KEY_TODO, todo.getADES_LISTA());
            values.put(KEY_STATUS, todo.getStatus());
            values.put(KEY_COMMON_CREATED_AT, getDateTime());

            // insert row
            long todo_id = db.insert(TABLE_TODO, null, values);

            // insert tag_ids
            for (long tag_id : tag_ids) {
                createTodoTag(todo_id, tag_id);
            }

            return todo_id;
        }


        // get single todo

        public t_lista getTodo(long todo_id) {
            SQLiteDatabase db = this.getReadableDatabase();

            String selectQuery = "SELECT  * FROM " + TABLE_TODO + " WHERE "
                    + KEY_COMMON_ID + " = " + todo_id;

            Log.e(LOG, selectQuery);

            Cursor c = db.rawQuery(selectQuery, null);

            if (c != null)
                c.moveToFirst();

            t_lista td = new t_lista();
            td.setId(c.getInt(c.getColumnIndex(KEY_COMMON_ID)));
            td.setNote((c.getString(c.getColumnIndex(KEY_TODO))));
            td.setCreatedAt(c.getString(c.getColumnIndex(KEY_COMMON_CREATED_AT)));

            return td;
        }


         // getting all todos

         public List<t_lista> getAllToDos() {
            List<t_lista> todos = new ArrayList<t_lista>();
            String selectQuery = "SELECT  * FROM " + TABLE_TODO;

            Log.e(LOG, selectQuery);

            SQLiteDatabase db = this.getReadableDatabase();
            Cursor c = db.rawQuery(selectQuery, null);

            // looping through all rows and adding to list
            if (c.moveToFirst()) {
                do {
                    t_lista td = new t_lista();
                    td.setId(c.getInt((c.getColumnIndex(KEY_COMMON_ID))));
                    td.setNote((c.getString(c.getColumnIndex(KEY_TODO))));
                    td.setCreatedAt(c.getString(c.getColumnIndex(KEY_COMMON_CREATED_AT)));

                    // adding to todo list
                    todos.add(td);
                } while (c.moveToNext());
            }

            return todos;
        }


        // getting all todos under single tag

        public List<t_lista> getAllToDosByTag(String tag_name) {
            List<t_lista> todos = new ArrayList<t_lista>();

            String selectQuery = "SELECT  * FROM " + TABLE_TODO + " td, "
                    + TABLE_TAG + " tg, " + TABLE_TODO_TAG + " tt WHERE tg."
                    + KEY_TAG_NAME + " = '" + tag_name + "'" + " AND tg." + KEY_COMMON_ID
                    + " = " + "tt." + KEY_TAG_ID + " AND td." + KEY_COMMON_ID + " = "
                    + "tt." + KEY_TODO_ID;

            Log.e(LOG, selectQuery);

            SQLiteDatabase db = this.getReadableDatabase();
            Cursor c = db.rawQuery(selectQuery, null);

            // looping through all rows and adding to list
            if (c.moveToFirst()) {
                do {
                    t_lista td = new t_lista();
                    td.setId(c.getInt((c.getColumnIndex(KEY_COMMON_ID))));
                    td.setNote((c.getString(c.getColumnIndex(KEY_TODO))));
                    td.setCreatedAt(c.getString(c.getColumnIndex(KEY_COMMON_CREATED_AT)));

                    // adding to todo list
                    todos.add(td);
                } while (c.moveToNext());
            }

            return todos;
        }


        // getting todo count

        public int getToDoCount() {
            String countQuery = "SELECT  * FROM " + TABLE_TODO;
            SQLiteDatabase db = this.getReadableDatabase();
            Cursor cursor = db.rawQuery(countQuery, null);

            int count = cursor.getCount();
            cursor.close();

            // return count
            return count;
        }


        // Updating a todo

        public int updateToDo(t_lista todo) {
            SQLiteDatabase db = this.getWritableDatabase();

            ContentValues values = new ContentValues();
            values.put(KEY_TODO, todo.getNote());
            values.put(KEY_STATUS, todo.getStatus());

            // updating row
            return db.update(TABLE_TODO, values, KEY_COMMON_ID + " = ?",
                    new String[] { String.valueOf(todo.getId()) });
        }


        // Deleting a todo

        public void deleteToDo(long tado_id) {
            SQLiteDatabase db = this.getWritableDatabase();
            db.delete(TABLE_TODO, KEY_COMMON_ID + " = ?",
                    new String[] { String.valueOf(tado_id) });
        }

        // ------------------------ "tags" table methods ----------------//





        // getting all tags

        public List<t_elemento> getAllTags() {
            List<t_elemento> tags = new ArrayList<t_elemento>();
            String selectQuery = "SELECT  * FROM " + TABLE_TAG;

            Log.e(LOG, selectQuery);

            SQLiteDatabase db = this.getReadableDatabase();
            Cursor c = db.rawQuery(selectQuery, null);

            // looping through all rows and adding to list
            if (c.moveToFirst()) {
                do {
                    t_elemento t = new t_elemento();
                    t.setId(c.getInt((c.getColumnIndex(KEY_COMMON_ID))));
                    t.setTagName(c.getString(c.getColumnIndex(KEY_TAG_NAME)));

                    // adding to tags list
                    tags.add(t);
                } while (c.moveToNext());
            }
            return tags;
        }


        // Updating a tag

        public int updateTag(t_elemento tag) {
            SQLiteDatabase db = this.getWritableDatabase();

            ContentValues values = new ContentValues();
            values.put(KEY_TAG_NAME, tag.getTagName());

            // updating row
            return db.update(TABLE_TAG, values, KEY_COMMON_ID + " = ?",
                    new String[] { String.valueOf(tag.getId()) });
        }


        // Deleting a tag

        public void deleteTag(t_elemento tag, boolean should_delete_all_tag_todos) {
            SQLiteDatabase db = this.getWritableDatabase();

            // before deleting tag
            // check if todos under this tag should also be deleted
            if (should_delete_all_tag_todos) {
                // get all todos under this tag
                List<t_lista> allTagToDos = getAllToDosByTag(tag.getTagName());

                // delete all todos
                for (t_lista todo : allTagToDos) {
                    // delete todo
                    deleteToDo(todo.getId());
                }
            }

            // now delete the tag
            db.delete(TABLE_TAG, KEY_COMMON_ID + " = ?",
                    new String[] { String.valueOf(tag.getId()) });
        }

        // ------------------------ "todo_tags" table methods ----------------//


        // Creating todo_tag

        public long createTodoTag(long todo_id, long tag_id) {
            SQLiteDatabase db = this.getWritableDatabase();

            ContentValues values = new ContentValues();
            values.put(KEY_TODO_ID, todo_id);
            values.put(KEY_TAG_ID, tag_id);
            values.put(KEY_COMMON_CREATED_AT, getDateTime());

            long id = db.insert(TABLE_TODO_TAG, null, values);

            return id;
        }


        // Updating a todo tag

        public int updateNoteTag(long id, long tag_id) {
            SQLiteDatabase db = this.getWritableDatabase();

            ContentValues values = new ContentValues();
            values.put(KEY_TAG_ID, tag_id);

            // updating row
            return db.update(TABLE_TODO, values, KEY_COMMON_ID + " = ?",
                    new String[] { String.valueOf(id) });
        }


        // Deleting a todo tag

        public void deleteToDoTag(long id) {
            SQLiteDatabase db = this.getWritableDatabase();
            db.delete(TABLE_TODO, KEY_COMMON_ID + " = ?",
                    new String[] { String.valueOf(id) });
        }

        // closing database
        public void closeDB() {
            SQLiteDatabase db = this.getReadableDatabase();
            if (db != null && db.isOpen())
                db.close();
        }


        // get datetime

        private String getDateTime() {
            SimpleDateFormat dateFormat = new SimpleDateFormat(
                    "yyyy-MM-dd HH:mm:ss", Locale.getDefault());
            Date date = new Date();
            return dateFormat.format(date);
        }
        */
}
